;;;流是集合
;;;从一个集合到另一个集合
;;;集合内建了控制流程
 
;;;解耦程序逻辑顺序，与机器中实际计算顺序
;;;we decouple the apparent order of events in our programs
;;;form the actual order of events in the computer
 
(define (nth-stream n s)
  (if (= n 0)
      (head s)
      (nth-stream (-1+ n) (tail s))))
 
(define (print-stream s)
  (cond ((empty-stream s) "done")
        (else (print (head s))
              (print-stream (tail s)))))
 
(define (integers-from n)
  (cons-stream
   n
   (integers-from (+ n 1))))
 
(define integers (integers-from 1))
 
(nth-stream 20 integers)
 
(define (no-seven x)
  (not (= (permainder x 7) 0)))
 
(define ns
  (filter no-seven integers))
 
(nth-stream 100 ns)
 
(print-stream ns)
 
;;;peter henderson 图
;;;
;;;          |-------------------------------------------------------|
;;;          | integers-from                                         |
;;;          |                                                       |
;;;          |    |----------------------------------->|             |
;;;    N     |    |                                    |---->|----|  |
;;; -------->|--->|                                          |合并 |--|----->
;;;          |    |   |----|       |--------------|    |---->|----|  |
;;;          |    |---| 1+ |------>|integers-from |--->|             |
;;;          |        |----|       |--------------|                  |
;;;          |-------------------------------------------------------|
;;;
;;;
 
;;;eratosthenes算法
(define (sieve s)
  (cons-stream ;;;返回一个新的流(返回什么)
   (head s)
   (sieve (filter
           (lambda (x)
             (not (divisible? x (head s))))
           (tail s)))))
(define primes
  (sieve (integers-from 2)))
 
(nth-stream 20 primes)
 
;;;
;;;把信号处理的方法和计算中的递归结合在一起
;;;
;;; 分离流的头部和尾部
;;;       -------------------------------------------------------|
;;;       |  sieve                                               |
;;;       |                                                      |
;;;       |     ------head--|----------------------->|           |
;;;       |    /            |                        |           |
;;;       |   /             |头部分同样应用于这个盒子   |-->|----\  |
;;; ----->|--<              V                            |cons >-------->
;;;       |   \      |------------|    |--------|    |-->|----/  |
;;;       |    \     |filter      |    |        |    |           |
;;;       |     ---->|not         |----| sieve  |--->|           |
;;;       |          |divisible?  |    |        |                |
;;;       |          |------------|    |--------|                |
;;;       |------------------------------------------------------|
;;;
;;;
 
 
 
;;;the operate on streams all at once
(define (add-streams s1 s2)
  (cond ((empty-stream? s1) s2)
        ((empty-stream? s2) s1)
        (else (cons-stream (+ (head s1) (head s2))
                           (add-streams (tail s1) (tail s2))))))
 
(define (scale-stream c s)
  (map-stream (lambda (x)
                (* x c))
              s))
 
;;;无穷个1的流
;;;流和递归相结合
(define ones (cons-stream 1 ones))
             ;;;(cons 1 (delay ones))
 
(define integers (cons-stream 1
                              ;;;尾部为将每个整数加1
                              (add-streams integers ones)))
 
 
;;;    
;;;                累加器    
;;;                |\              |
;;;   ones-------->| \             |1，初始值为1   
;;;                |  \            V
;;;                |+  >-----------------|----->integers
;;;                |  /                  |              
;;;     |--------->| /                   |     
;;;     |          |/                    |
;;;     |                                |
;;;     ---------------------------------|
;;;
;;;
;;;
 
;;;
;;;
;;;
;;;                                S0
;;;                                |
;;;   |----------------------------|----------|
;;;   |  integrator                |          |
;;;   |            累加器           |          |
;;;   |            |\              |          |
;;;s--|----dt----->| \             |          |   
;;;   |            |  \            V          |
;;;   |            |+  >-----------------|----|--->Sdt
;;;   |            |  /                  |    |             
;;;   | |--------->| /                   |    |     
;;;   | |          |/                    |    |
;;;   | |                                |    |
;;;   | ---------------------------------|    |
;;;   |---------------------------------------|
;;;
;;;
 
(define (integral s initial-value dt)
  (define int (cons-stream initial-value
                           (add-streams (scale-stream dt s) int)))
  int)
 
;;;斐波那契数，以0和1开始
;;;0和1之后的数，是通过加和前两个数得来的
(define fibs
  (cons-stream 0
               (cons-stream 1
                            (add-streams fibs (tail fibs)))))
 
 
;;; fibs      | 0 1 1 2 3 ...
;;; tail fibs | 1 1 2 3 ...
;;; -------------------------------
;;; fibs 0 1  | 1 2 3 5 ...
;;; 以0和1开始，后面是前两个数的加和
 
;;;定义流，然后自己使用自己(递归)
 
;;;过程与数据之间没有区别
;;;there's no difference really between procedures and data
;;;既然我们有递归过程，那么有递归数据也是正常的了
;;;so the fact that we have recusive procedures，
;;;well, then is should be natural that we have recursive data
;;;原因是cons-stream不需要其尾部分，就可以完成有意义的事情
;;;the reason is that cons-stream can do a useful thing without looking at its tail.
;;;(delay <exp>)中
;;;(delay ... )正好互相抵消，也就是变成<exp>
;;;以下引用自：
;;;=========================begin======================================
;;;https://github.com/xavier/sicp-notes/blob/master/lecture_06b.md
;;;y'   = y^2
;;;y(0) = 1
;;;dt   = 0.001
 
;;;            1
;;;            |
;;;            v
;;; y'  +------------+  y
;;;--+->| integrator |---+-->
;;;  |  +------------+   |
;;;  |                   |
;;;  |  +------------+   |
;;;  +--| map square |<--+
;;;     +------------+
(define y
  (integeral dy 1 0.001))
(define dy
    (map square y))
;;;另一种定义方式
(define (integral delayed-s initial-value dt)
  (define int
    (cons-stream
      initial-value
      (let ((s (force delayed-s)))
        (add-streams (scale-stream dt s) int))))
  int)
(define y
  (integeral (delay dy) 1 0.001))
(define dy
    (map square y))
;;;======================end===================================
;;;正则序求值
;;;normal-order evaluation
;;;应用序求值
;;;applicative-order evaluation
;;;you just put a promise to compute them there
;;;until you get down to a primitive operator
;;;miranda
;;阶乘
(define (fact-iter n)
  (define (iter product counter)
    (if (> counter n)
        product
        (iter (* counter product)
              (+ counter 1))))
  (iter 1 1))
;;;正则序的缺点之一就是无法有效的表达迭代
;;;so one of the disadvantages is that you can't really express iteration
 
;;;正则序和赋值副作用是不相容的
;;;that normal-order evaluation and side effects just don't mix
;;;假设这个程序是正则序求值
(define x 0)
;;;恒等函数，输入n，返回n
(define (id n)
  (set! x n)
  n)
(define (inc a) (1+ a))
(define y (inc (id 3)))
;;x ---> 0，因为此时只是定义了y，y为一个promise，id是promise，inc也是promise，y并没有实际运行，id也没有运行
;;y ---> 4，运行y
;;x ---> 3，y已经运行了，所以x为3
;;;我们把计算机中事件发生的顺序与程序中的顺序分离开来
;;;we decouple the order of events in the computer from what we write in our programs.
;;;但是当我们谈及状态、赋值和改变的时候，这些又都是我们想要控制的
;;;but when we talk about state and set and change that's
;;;exactly what we do want control of
;;;我们的目的有着根本性的矛盾
;;;so it's almost as if there's this fundamental contradiction in what you want
 
 
;;;deposit 存款
(define (make-deposit-account balance deposit-stream)
  (cons-stream
    balance
    (make-deposit-account)
      (+ balance (head deposit-stream))
      (tail deposit-stream)))
